{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"red\">注</font>: 使用 tensorboard 可视化需要安装 tensorflow (TensorBoard依赖于tensorflow库，可以任意安装tensorflow的gpu/cpu版本)\n",
    "\n",
    "```shell\n",
    "pip install tensorflow-cpu\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:08.125203900Z",
     "start_time": "2024-04-29T02:49:56.553689Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:22:11.381575Z",
     "iopub.status.busy": "2025-01-23T02:22:11.381269Z",
     "iopub.status.idle": "2025-01-23T02:22:13.337951Z",
     "shell.execute_reply": "2025-01-23T02:22:13.337492Z",
     "shell.execute_reply.started": "2025-01-23T02:22:11.381556Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=10, micro=14, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cu124\n",
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据准备\n",
    "\n",
    "https://www.kaggle.com/competitions/cifar-10/data\n",
    "\n",
    "```shell\n",
    "$ tree -L 1 cifar-10                                    \n",
    "cifar-10\n",
    "├── sampleSubmission.csv\n",
    "├── test\n",
    "├── train\n",
    "└── trainLabels.csv\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:01.391389Z",
     "iopub.status.busy": "2025-01-21T06:46:01.390831Z",
     "iopub.status.idle": "2025-01-21T06:46:01.393562Z",
     "shell.execute_reply": "2025-01-21T06:46:01.393101Z",
     "shell.execute_reply.started": "2025-01-21T06:46:01.391365Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# %pip install py7zr\n",
    "# import py7zr\n",
    "# a = py7zr.SevenZipFile(r'../input/cifar-10/train.7z','r')\n",
    "# a.extractall(path=r'./')\n",
    "# a.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T02:22:28.730202Z",
     "iopub.status.busy": "2025-01-23T02:22:28.729877Z",
     "iopub.status.idle": "2025-01-23T02:22:28.844070Z",
     "shell.execute_reply": "2025-01-23T02:22:28.843529Z",
     "shell.execute_reply.started": "2025-01-23T02:22:28.730182Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01-classification_model-cnn.ipynb\n",
      "02_classification_model-cnn-selu.ipynb\n",
      "03_classification_model-separable_cnn.ipynb\n",
      "04_10_monkeys_model_1_冲突文件_Administrator_20240815203110.ipynb\n",
      "04_10_monkeys_model_1_aliyun.ipynb\n",
      "04_10_monkeys_model_1.ipynb\n",
      "05_10_monkeys_model_2_resnet50_finetune_2aliyun.ipynb\n",
      "05_10_monkeys_model_2_resnet50_finetune_冲突文件_Administrator_20240815203110.ipynb\n",
      "05_10_monkeys_model_2_resnet50_finetune.ipynb\n",
      "06_cifar10_model_1_冲突文件_Administrator_20240815203110.ipynb\n",
      "06_cifar10_model_1.ipynb\n",
      "06_cifar10_model_2-aliyun.ipynb\n",
      "archive\n",
      "checkpoints\n",
      "competitions\n",
      "data\n",
      "kaggle.json\n",
      "new_inception_net2-aliyun.ipynb\n",
      "new_resnet-aliyun.ipynb\n",
      "new-vgg-aliyun.ipynb\n",
      "runs\n",
      "sampleSubmission.csv\n",
      "submission.csv\n",
      "test.7z\n",
      "train.7z\n",
      "trainLabels.csv\n"
     ]
    }
   ],
   "source": [
    "#我们不运行test数据集，太多图片\n",
    "!ls ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-21T06:46:01.513073Z",
     "iopub.status.busy": "2025-01-21T06:46:01.512470Z",
     "iopub.status.idle": "2025-01-21T06:46:01.627751Z",
     "shell.execute_reply": "2025-01-21T06:46:01.627129Z",
     "shell.execute_reply.started": "2025-01-21T06:46:01.513038Z"
    }
   },
   "outputs": [],
   "source": [
    "!mkdir test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:17.556866200Z",
     "start_time": "2024-04-29T02:50:13.332056200Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:37.823791Z",
     "iopub.status.busy": "2025-01-23T02:23:37.823457Z",
     "iopub.status.idle": "2025-01-23T02:23:39.668360Z",
     "shell.execute_reply": "2025-01-23T02:23:39.667911Z",
     "shell.execute_reply.started": "2025-01-23T02:23:37.823771Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(PosixPath('competitions/cifar-10/train/1.png'), 'frog'),\n",
      " (PosixPath('competitions/cifar-10/train/2.png'), 'truck'),\n",
      " (PosixPath('competitions/cifar-10/train/3.png'), 'truck'),\n",
      " (PosixPath('competitions/cifar-10/train/4.png'), 'deer'),\n",
      " (PosixPath('competitions/cifar-10/train/5.png'), 'automobile')]\n",
      "[(PosixPath('competitions/cifar-10/test/1.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/2.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/3.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/4.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/5.png'), 'cat')]\n",
      "50000 300000\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "DATA_DIR = Path(\".\")\n",
    "DATA_DIR1 =Path(\"competitions/cifar-10/\")\n",
    "train_lables_file = DATA_DIR / \"trainLabels.csv\"\n",
    "test_csv_file = DATA_DIR / \"sampleSubmission.csv\" #测试集模板csv文件\n",
    "train_folder = DATA_DIR1 / \"train\"\n",
    "test_folder = DATA_DIR1 / \"test\"\n",
    "\n",
    "#所有的类别\n",
    "class_names = [\n",
    "    'airplane',\n",
    "    'automobile',\n",
    "    'bird',\n",
    "    'cat',\n",
    "    'deer',\n",
    "    'dog',\n",
    "    'frog',\n",
    "    'horse',\n",
    "    'ship',\n",
    "    'truck',\n",
    "]\n",
    "\n",
    "def parse_csv_file(filepath, folder):\n",
    "    \"\"\"Parses csv files into (filename(path), label) format\"\"\"\n",
    "    results = []\n",
    "    #读取所有行\n",
    "    with open(filepath, 'r') as f:\n",
    "#         lines = f.readlines()  为什么加[1:]，可以试这个\n",
    "        #第一行不需要，因为第一行是标签\n",
    "        lines = f.readlines()[1:] \n",
    "    for line in lines:#依次去取每一行\n",
    "        image_id, label_str = line.strip('\\n').split(',')\n",
    "        image_full_path = folder / f\"{image_id}.png\"\n",
    "        results.append((image_full_path, label_str)) #得到对应图片的路径和分类\n",
    "    return results\n",
    "\n",
    "#解析对应的文件夹\n",
    "train_labels_info = parse_csv_file(train_lables_file, train_folder)\n",
    "test_csv_info = parse_csv_file(test_csv_file, test_folder)\n",
    "#打印\n",
    "import pprint\n",
    "pprint.pprint(train_labels_info[0:5])\n",
    "pprint.pprint(test_csv_info[0:5])\n",
    "print(len(train_labels_info), len(test_csv_info))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:22.471835700Z",
     "start_time": "2024-04-29T02:50:22.346907200Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:46.790959Z",
     "iopub.status.busy": "2025-01-23T02:23:46.790636Z",
     "iopub.status.idle": "2025-01-23T02:23:46.848363Z",
     "shell.execute_reply": "2025-01-23T02:23:46.847924Z",
     "shell.execute_reply.started": "2025-01-23T02:23:46.790940Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            filepath       class\n",
      "0  competitions/cifar-10/train/1.png        frog\n",
      "1  competitions/cifar-10/train/2.png       truck\n",
      "2  competitions/cifar-10/train/3.png       truck\n",
      "3  competitions/cifar-10/train/4.png        deer\n",
      "4  competitions/cifar-10/train/5.png  automobile\n",
      "                                filepath       class\n",
      "0  competitions/cifar-10/train/45001.png       horse\n",
      "1  competitions/cifar-10/train/45002.png  automobile\n",
      "2  competitions/cifar-10/train/45003.png        deer\n",
      "3  competitions/cifar-10/train/45004.png  automobile\n",
      "4  competitions/cifar-10/train/45005.png    airplane\n",
      "                           filepath class\n",
      "0  competitions/cifar-10/test/1.png   cat\n",
      "1  competitions/cifar-10/test/2.png   cat\n",
      "2  competitions/cifar-10/test/3.png   cat\n",
      "3  competitions/cifar-10/test/4.png   cat\n",
      "4  competitions/cifar-10/test/5.png   cat\n"
     ]
    }
   ],
   "source": [
    "# train_df = pd.DataFrame(train_labels_info)\n",
    "train_df = pd.DataFrame(train_labels_info[0:45000])\n",
    "valid_df = pd.DataFrame(train_labels_info[45000:])\n",
    "test_df = pd.DataFrame(test_csv_info)\n",
    "\n",
    "train_df.columns = ['filepath', 'class']\n",
    "valid_df.columns = ['filepath', 'class']\n",
    "test_df.columns = ['filepath', 'class']\n",
    "\n",
    "print(train_df.head())\n",
    "print(valid_df.head())\n",
    "print(test_df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:31.586523100Z",
     "start_time": "2024-04-29T02:50:28.504142500Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:46.849430Z",
     "iopub.status.busy": "2025-01-23T02:23:46.849072Z",
     "iopub.status.idle": "2025-01-23T02:23:48.877917Z",
     "shell.execute_reply": "2025-01-23T02:23:48.877447Z",
     "shell.execute_reply.started": "2025-01-23T02:23:46.849413Z"
    }
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torchvision import transforms\n",
    "\n",
    "class Cifar10Dataset(Dataset):\n",
    "    df_map = {\n",
    "        \"train\": train_df,\n",
    "        \"eval\": valid_df,\n",
    "        \"test\": test_df\n",
    "    }\n",
    "    label_to_idx = {label: idx for idx, label in enumerate(class_names)}\n",
    "    idx_to_label = {idx: label for idx, label in enumerate(class_names)}\n",
    "    def __init__(self, mode, transform=None):\n",
    "        self.df = self.df_map.get(mode, None)\n",
    "        if self.df is None:\n",
    "            raise ValueError(\"mode should be one of train, val, test, but got {}\".format(mode))\n",
    "\n",
    "        self.transform = transform\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        img_path, label = self.df.iloc[index]\n",
    "        img = Image.open(img_path).convert('RGB')\n",
    "        # # img 转换为 channel first\n",
    "        # img = img.transpose((2, 0, 1))\n",
    "        # transform\n",
    "        img = self.transform(img)\n",
    "        # label 转换为 idx\n",
    "        label = self.label_to_idx[label]\n",
    "        return img, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.df.shape[0]\n",
    "    \n",
    "IMAGE_SIZE = 32\n",
    "mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]\n",
    "\n",
    "transforms_train = transforms.Compose([\n",
    "        # resize\n",
    "        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),\n",
    "        # random rotation 40\n",
    "        transforms.RandomRotation(40),\n",
    "        # horizaontal flip\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean, std)\n",
    "    ])\n",
    "\n",
    "transforms_eval = transforms.Compose([\n",
    "        # resize\n",
    "        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean, std)\n",
    "    ])\n",
    "\n",
    "train_ds = Cifar10Dataset(\"train\", transforms_train)\n",
    "eval_ds = Cifar10Dataset(\"eval\", transforms_eval) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:51:31.864180800Z",
     "start_time": "2024-04-29T02:51:31.841167400Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:48.878818Z",
     "iopub.status.busy": "2025-01-23T02:23:48.878482Z",
     "iopub.status.idle": "2025-01-23T02:23:48.881906Z",
     "shell.execute_reply": "2025-01-23T02:23:48.881432Z",
     "shell.execute_reply.started": "2025-01-23T02:23:48.878800Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, num_workers=4)   \n",
    "eval_dl = DataLoader(eval_ds, batch_size=batch_size, shuffle=False, num_workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:19.396136500Z",
     "start_time": "2023-12-05T09:46:43.935044500Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:48.883150Z",
     "iopub.status.busy": "2025-01-23T02:23:48.882884Z",
     "iopub.status.idle": "2025-01-23T02:23:48.885321Z",
     "shell.execute_reply": "2025-01-23T02:23:48.884903Z",
     "shell.execute_reply.started": "2025-01-23T02:23:48.883136Z"
    }
   },
   "outputs": [],
   "source": [
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "#这里不需要每次都执行，只需要执行一次就可以了，所以注释掉\n",
    "# def cal_mean_std(ds):\n",
    "#     mean = 0.\n",
    "#     std = 0.\n",
    "#     for img, _ in ds:\n",
    "#         mean += img.mean(dim=(1, 2))\n",
    "#         std += img.std(dim=(1, 2))\n",
    "#     mean /= len(ds)\n",
    "#     std /= len(ds)\n",
    "#     return mean, std\n",
    "#\n",
    "# # 经过 normalize 后 均值为0，方差为1\n",
    "# print(cal_mean_std(train_ds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:52:55.126913100Z",
     "start_time": "2024-04-29T02:52:55.080936200Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:48.885894Z",
     "iopub.status.busy": "2025-01-23T02:23:48.885750Z",
     "iopub.status.idle": "2025-01-23T02:23:48.913842Z",
     "shell.execute_reply": "2025-01-23T02:23:48.913435Z",
     "shell.execute_reply.started": "2025-01-23T02:23:48.885880Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             model.0.weight             paramerters num: 864\n",
      "              model.0.bias              paramerters num: 32\n",
      "             model.2.weight             paramerters num: 9216\n",
      "              model.2.bias              paramerters num: 32\n",
      "             model.5.weight             paramerters num: 9216\n",
      "              model.5.bias              paramerters num: 32\n",
      "             model.7.weight             paramerters num: 9216\n",
      "              model.7.bias              paramerters num: 32\n",
      "            model.10.weight             paramerters num: 9216\n",
      "             model.10.bias              paramerters num: 32\n",
      "            model.12.weight             paramerters num: 9216\n",
      "             model.12.bias              paramerters num: 32\n",
      "            model.16.weight             paramerters num: 5120\n",
      "             model.16.bias              paramerters num: 10\n"
     ]
    }
   ],
   "source": [
    "class VGG(nn.Module):\n",
    "    def __init__(self, num_classes):\n",
    "        super().__init__()\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=\"same\"),# 32*32*32\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*32*32\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*16*16\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*16*16\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*8*8\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*8*8\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2), # 32*4*4\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(512, num_classes),\n",
    "        )\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层、卷积层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, (nn.Linear, nn.Conv2d)):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "        \n",
    "for key, value in VGG(len(class_names)).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-21T06:41:50.445101Z",
     "start_time": "2025-01-21T06:41:50.441569Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:48.914459Z",
     "iopub.status.busy": "2025-01-23T02:23:48.914311Z",
     "iopub.status.idle": "2025-01-23T02:23:48.917885Z",
     "shell.execute_reply": "2025-01-23T02:23:48.917525Z",
     "shell.execute_reply.started": "2025-01-23T02:23:48.914445Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "512"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "32*4*4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练\n",
    "\n",
    "pytorch的训练需要自行实现，包括\n",
    "1. 定义损失函数\n",
    "2. 定义优化器\n",
    "3. 定义训练步\n",
    "4. 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T08:24:38.083191700Z",
     "start_time": "2024-07-23T08:24:38.072843500Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:48.918622Z",
     "iopub.status.busy": "2025-01-23T02:23:48.918323Z",
     "iopub.status.idle": "2025-01-23T02:23:48.921121Z",
     "shell.execute_reply": "2025-01-23T02:23:48.920736Z",
     "shell.execute_reply.started": "2025-01-23T02:23:48.918608Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "512"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "32*16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:53:41.778122600Z",
     "start_time": "2024-04-29T02:53:41.736145400Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:48.921703Z",
     "iopub.status.busy": "2025-01-23T02:23:48.921570Z",
     "iopub.status.idle": "2025-01-23T02:23:48.925701Z",
     "shell.execute_reply": "2025-01-23T02:23:48.925340Z",
     "shell.execute_reply.started": "2025-01-23T02:23:48.921690Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total trainable parameters: 52266\n"
     ]
    }
   ],
   "source": [
    "#模型总参数量\n",
    "total_params = sum(p.numel() for p in VGG(len(class_names)).parameters() if p.requires_grad)\n",
    "print(f\"Total trainable parameters: {total_params}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:19.650361500Z",
     "start_time": "2023-12-05T09:51:19.432189700Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:48.926417Z",
     "iopub.status.busy": "2025-01-23T02:23:48.926129Z",
     "iopub.status.idle": "2025-01-23T02:23:49.018880Z",
     "shell.execute_reply": "2025-01-23T02:23:49.018439Z",
     "shell.execute_reply.started": "2025-01-23T02:23:48.926403Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:26.334347900Z",
     "start_time": "2023-12-05T09:51:19.656342Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:49.020611Z",
     "iopub.status.busy": "2025-01-23T02:23:49.020185Z",
     "iopub.status.idle": "2025-01-23T02:23:49.205543Z",
     "shell.execute_reply": "2025-01-23T02:23:49.205102Z",
     "shell.execute_reply.started": "2025-01-23T02:23:49.020593Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:26.347424300Z",
     "start_time": "2023-12-05T09:51:26.337347300Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:49.206459Z",
     "iopub.status.busy": "2025-01-23T02:23:49.206098Z",
     "iopub.status.idle": "2025-01-23T02:23:49.210650Z",
     "shell.execute_reply": "2025-01-23T02:23:49.210237Z",
     "shell.execute_reply.started": "2025-01-23T02:23:49.206442Z"
    }
   },
   "outputs": [],
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:26.371402100Z",
     "start_time": "2023-12-05T09:51:26.351411800Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:49.211366Z",
     "iopub.status.busy": "2025-01-23T02:23:49.211151Z",
     "iopub.status.idle": "2025-01-23T02:23:49.214762Z",
     "shell.execute_reply": "2025-01-23T02:23:49.214371Z",
     "shell.execute_reply.started": "2025-01-23T02:23:49.211351Z"
    }
   },
   "outputs": [],
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2023-12-05T09:51:26.364406400Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T02:23:49.215529Z",
     "iopub.status.busy": "2025-01-23T02:23:49.215387Z",
     "iopub.status.idle": "2025-01-23T02:25:05.133742Z",
     "shell.execute_reply": "2025-01-23T02:25:05.133227Z",
     "shell.execute_reply.started": "2025-01-23T02:23:49.215516Z"
    },
    "is_executing": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 7040/7040 [01:15<00:00, 93.17it/s, epoch=9] \n"
     ]
    }
   ],
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 10\n",
    "\n",
    "model = VGG(num_classes=10)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "#可以修改adam里边的weight_decay参数，来控制L2正则化的程度,beta1和beta2是指数衰减率\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/vgg\")\n",
    "tensorboard_callback.draw_model(model, [1, 3, IMAGE_SIZE, IMAGE_SIZE])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/vgg\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=5)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    eval_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T02:25:05.134597Z",
     "iopub.status.busy": "2025-01-23T02:25:05.134369Z",
     "iopub.status.idle": "2025-01-23T02:25:05.362121Z",
     "shell.execute_reply": "2025-01-23T02:25:05.361653Z",
     "shell.execute_reply.started": "2025-01-23T02:25:05.134578Z"
    },
    "is_executing": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=100)  #横坐标是 steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T02:25:05.362910Z",
     "iopub.status.busy": "2025-01-23T02:25:05.362675Z",
     "iopub.status.idle": "2025-01-23T02:25:06.057079Z",
     "shell.execute_reply": "2025-01-23T02:25:06.056586Z",
     "shell.execute_reply.started": "2025-01-23T02:25:05.362893Z"
    },
    "is_executing": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_349/244139278.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  model.load_state_dict(torch.load(\"checkpoints/vgg/best.ckpt\", map_location=\"cpu\"))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.8990\n",
      "accuracy: 0.6938\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/vgg/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, eval_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 推理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T02:25:06.057906Z",
     "iopub.status.busy": "2025-01-23T02:25:06.057671Z",
     "iopub.status.idle": "2025-01-23T02:25:06.060371Z",
     "shell.execute_reply": "2025-01-23T02:25:06.059957Z",
     "shell.execute_reply.started": "2025-01-23T02:25:06.057888Z"
    },
    "is_executing": true
   },
   "outputs": [],
   "source": [
    "# # test_df\n",
    "# test_ds = Cifar10Dataset(\"test\", transform=transforms_eval)\n",
    "# test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, drop_last=False)\n",
    "#\n",
    "# preds_collect = []\n",
    "# model.eval()\n",
    "# for data, fake_label in tqdm(test_dl):\n",
    "#     data = data.to(device=device)\n",
    "#     logits = model(data)\n",
    "#     preds = [test_ds.idx_to_label[idx] for idx in logits.argmax(axis=-1).cpu().tolist()]\n",
    "#     preds_collect.extend(preds)\n",
    "#\n",
    "# test_df[\"class\"] = preds_collect\n",
    "# test_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T02:25:06.060985Z",
     "iopub.status.busy": "2025-01-23T02:25:06.060849Z",
     "iopub.status.idle": "2025-01-23T02:25:06.063139Z",
     "shell.execute_reply": "2025-01-23T02:25:06.062589Z",
     "shell.execute_reply.started": "2025-01-23T02:25:06.060972Z"
    },
    "is_executing": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "# # 导出 submission.csv\n",
    "# test_df.to_csv(\"submission.csv\", index=False)"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [
    {
     "databundleVersionId": 46718,
     "sourceId": 3649,
     "sourceType": "competition"
    }
   ],
   "dockerImageVersionId": 30588,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
